home *** CD-ROM | disk | FTP | other *** search
/ No Fragments Archive 12: Textmags & Docs / nf_archive_12.iso / MAGS / SOURCES / ATARI_SRC.ZIP / atari source / HDX_BACK / SHOWFILE / WIND.D < prev    next >
Encoding:
Text File  |  2001-02-09  |  17.5 KB  |  887 lines
  1. /* hdx.c */
  2.  
  3.  
  4. #include "obdefs.h"
  5. #include "gemdefs.h"
  6. #include "osbind.h"
  7. #include "mydefs.h"
  8. #include "wind.h"
  9. #include "addr.h"
  10. #include "error.h"
  11. #include "errno.h"
  12. #include "stdio.h"
  13. #include "stat.h"
  14.  
  15.  
  16. #define APP_INFO ""
  17. #define APP_NAME "Window Example"
  18. #define MAX(X,Y)    ( (X) > (Y) ? (X) : (Y) )
  19. #define MIN(X,Y)    ( (X) < (Y) ? (X) : (Y) )
  20.  
  21.  
  22. /* AES (windows and messages) related variables */
  23. int gl_hchar;        /* height of system font (pixels) */
  24. int gl_wchar;        /* width of system font (pixels) */
  25. int gl_wbox;        /* width of box able to hold system font */
  26. int gl_hbox;        /* height of box able to hold system font */
  27.  
  28. int phys_handle;    /* physical workstation handle */
  29. int handle;        /* virtual workstation handle */
  30. int wi_handle;        /* window handle */
  31.  
  32. int formw, formh, sx, sy, lx, ly;    /* dialogue box dimensions */
  33. int xdesk, ydesk, hdesk, wdesk;        /* window X, Y, width, height */
  34. int xwork, ywork, hwork, wwork;        /* desktop and work areas */
  35.  
  36. char *sbuf[512];
  37. int msgbuff[8];        /* event message buffer */
  38. int keycode;        /* keycode returned by event-keyboard */
  39. int mx, my;        /* mouse x and y pos. */
  40. int butdown;        /* button state tested for, UP/DOWN */
  41. int ret;        /* dummy return variable */
  42. int hidden;        /* current state of cursor */
  43. int contrl[12];
  44. int intin[128];
  45. int ptsin[128];
  46. int intout[128];
  47. int ptsout[128];    /* storage wasted for idiotic bindings */
  48. int work_in[11];    /* Input to GSX parameter array */
  49. int work_out[57];    /* Output from GSX parameter array */
  50. int pxyarray[10];    /* input point array */
  51. int msg[8];            /* message buffer */
  52. int toptx;            /* the top line of text currently in the window */
  53. int cellw, cellh, chspcw, chspch;    /* size of default character font */
  54. char *dbuff;
  55. long *list;
  56. int nrow;
  57. int running;
  58.  
  59. /*
  60.  * Top level;
  61.  * we get control from the desktop.
  62.  */
  63. main()
  64. {
  65.  
  66.  
  67.     appl_init();
  68.     phys_handle=graf_handle(&gl_wchar, &gl_hchar, &gl_wbox, &gl_hbox);
  69.     wind_get(0, WF_WORKXYWH, &xdesk, &ydesk, &wdesk, &hdesk);
  70.     open_vwork();
  71.     /*
  72.     hw_handle=wind_create(0x0040&0x0080, xdesk, ydesk, wdesk, hdesk);
  73.     */
  74.  
  75.     if (!rsrc_load(RESOURCEFILE))    {
  76.         errs("[2][|", RESOURCEFILE, "][ EXIT ]");
  77.         goto doneit;
  78.     }
  79.     
  80.     /* Get all addresses of dialogues from resource file */
  81.     if (getalladdr() != OK) {
  82.         errs("[2][|", RESOURCEFILE, "][ EXIT ]");
  83.         goto doneit;
  84.     }
  85.  
  86.     ARROW_MOUSE;
  87.     menu_bar(menubar, 1);
  88.     running = TRUE;
  89.     while(running)    {
  90.         domulti();
  91.     }
  92.     menu_bar(menubar, 0);
  93.  
  94. doneit:
  95.     wind_delete(wi_handle);
  96.     Mfree(dbuff);
  97.     Mfree(list);
  98.     v_clsvwk(handle);
  99.     appl_exit();
  100. }
  101.  
  102. doopenwd()
  103. {
  104.  
  105.     int done = FALSE;
  106.     long slidsiz;
  107.     DMABUFFER dma;
  108.     int status, i, tmpy, tmpx, fp;
  109.     char *sbuff, *tem;
  110.     int attrib[4];
  111.     long *tmp;
  112.     int deskx, desky, deskw, deskh;
  113.  
  114.  
  115.     wi_handle=wind_create(0xFFFF, xdesk, ydesk, wdesk, hdesk);
  116.     wind_set(wi_handle, WF_INFO, APP_INFO, 0, 0);
  117.     wind_set(wi_handle, WF_NAME, APP_NAME, 0, 0);
  118.     wind_open(wi_handle, xdesk+30, ydesk+30, wdesk/2, hdesk/2);
  119.     wind_get(wi_handle, WF_WORKXYWH, &xwork, &ywork, &wwork, &hwork);
  120.  
  121.     toptx = 0;        /* start top line of text */
  122.  
  123. /*
  124.     vst_alignment(handle, 0, 5, &done, &done);     set text alignment
  125.     wind_calc(0, 0xFFFF,
  126.                 gl_wchar*5, gl_hchar*5, gl_wchar*TCOLS+4, hwork*SROWS+4,
  127.                 &xwork, &ywork, &wwork, &hwork);
  128. */
  129.     /* set the window to that size */
  130. /*
  131.     wind_set(wi_handle, WF_CURRXYWH, 
  132.                         xwork, ywork, wwork, hwork);
  133. */
  134.  
  135.     /* find slider size and set it */
  136.     slidsiz = (1000*(hwork-5)/gl_hchar) / nrow; 
  137.     /*
  138.     wind_set(wi_handle, WF_VSLSIZE, (int)slidsiz, 0, 0, 0);
  139.     */
  140.  
  141. /*
  142.     find the work area
  143.  
  144.     wind_get(wi_handle, WF_WORKXYWH, &xwork, &ywork, &wwork, &hwork);
  145. */
  146.  
  147.  
  148.     /* read the file into buffer */
  149.  
  150.     Fsetdta(&dma);
  151.     if ((status = Fsfirst("c:\\fmt.c", 0xF7)) != 0)
  152.         fatal(status, "fmt.c");
  153.     if ((sbuff = Malloc(dma.d_fsize + 1)) == NULL)
  154.         exit(1);
  155.     if ((dbuff = Malloc(dma.d_fsize + 1000)) == NULL)
  156.         exit(1);
  157.     if ((fp = Fopen("c:\\fmt.c", "rb")) < 0)    {
  158.         Mfree(sbuff);
  159.         Mfree(dbuff);
  160.         fatal(fp, "cannot open input file");
  161.     }
  162.     if ((status=Fread(fp, (long)dma.d_fsize, sbuff)) < 0)    {
  163.         Mfree(sbuff);
  164.         Mfree(dbuff);
  165.         fatal(status, "fmt.c");
  166.     }
  167.     nrow = findsiz(sbuff);
  168.     list = Malloc((long )nrow);
  169.     converstr(list, sbuff, dbuff);
  170.     vqm_attributes(wi_handle, attrib);
  171.     do_redraw(xwork, ywork, wwork, hwork);
  172.     /*
  173.     wind_update(1);
  174.     tmpy = ywork+3;
  175.     toptx = 0;
  176.     while (tmpy < hwork+3)    {
  177.         tmpy += 4*attrib[3]/5;
  178.         v_gtext(wi_handle, xwork, tmpy, *list++);
  179.         toptx++;
  180.     }
  181.     wind_update(0);
  182.     ARROW_MOUSE;
  183.     */
  184.     /*
  185.  
  186.     do
  187.     {
  188.         evnt_mesage(msg);     get message 
  189.         done = deal_msg();     and handle them
  190.     } while(!done);
  191.  
  192.     wind_delete(wi_handle);
  193.     Mfree(sbuff);
  194.     Mfree(dbuff);
  195.     Mfree(list);
  196.     */
  197.     Mfree(sbuff);
  198.  
  199. }
  200.  
  201. deal_msg()
  202. {
  203.     int done = FALSE;
  204.     long tmp;
  205.     GRECT box;
  206.  
  207.     box.g_x = xwork;
  208.     box.g_y = ywork;
  209.     box.g_h = hwork;
  210.     box.g_w = wwork;
  211.  
  212.     switch(msg[0])    {
  213.  
  214.         case  WM_REDRAW:        /* do the redraw by call redraw routine */
  215.             redraw(msg[3], (GRECT *)&msg[4]);
  216.             break;
  217.  
  218.         case  WM_TOPPED:        /* if topped, send to top */
  219.             wind_set(msg[3], WF_TOP, 0, 0, 0, 0);
  220.             break;
  221.  
  222.         case  WM_SIZED:            /* if sized, check for min size, then resize */
  223.             msg[6] = MAX(msg[6], gl_wchar*8);
  224.             msg[7] = MAX(msg[7], gl_hchar*4);
  225.             wind_set(msg[3], WF_CURRXYWH, msg[4], msg[5], msg[6], msg[7]);
  226.             redraw(msg[3], (GRECT *)&msg[4]);
  227.             break;
  228.  
  229.         case  WM_MOVED:            /* if moved, make sure the window stays on the
  230.                                    desktop */
  231.             if (msg[4] + msg[6] > xdesk + wdesk)    {
  232.                 msg[4] = xdesk + wdesk - msg[6];
  233.             } 
  234.             if (msg[5] + msg[7] > ydesk + hdesk)    {
  235.                 msg[5] = ydesk + hdesk - msg[7];
  236.             }
  237.             wind_set(msg[3], WF_CURRXYWH, msg[4], msg[5], msg[6], msg[7]);
  238.             break;
  239.  
  240.         case  WM_FULLED:        /* if fulled, do toggle routine */
  241.             toggle(msg[3]);
  242.             break;
  243.  
  244.         case  WM_CLOSED:        /* if closed, set flag */
  245.             wind_close(msg[3]);
  246.             done = TRUE;
  247.             break;
  248.  
  249.         case  WM_VSLID:            /* slide bar was dragged */
  250.             tmp = msg[4] * (nrow-hwork/gl_hchar) / 1000;    /* calc toptx */
  251.             toptx = tmp;
  252.             redraw(wi_handle, &box);    /* redraw window */
  253.             mvslide();
  254.             break;
  255.         case  WM_HSLID:            /* slide bar was dragged */
  256.             break;
  257.  
  258.         case  WM_ARROWED:
  259.             switch (msg[4])    {
  260.                 case 0:    /* page up */
  261.                     toptx = MAX(0, toptx-hwork/gl_hchar);
  262.                     break;
  263.  
  264.                 case 1:    /* page down */
  265.                     toptx = MIN(nrow-hwork/gl_hchar, toptx+hwork/gl_hchar);
  266.                     break;
  267.  
  268.                 case 2:    /* row up */
  269.                     toptx = MAX(0, toptx-1);
  270.                     break;
  271.  
  272.                 case 3:    /* row down */
  273.                     toptx = MIN(nrow-hwork/gl_hchar, toptx+1);
  274.                     break;
  275.  
  276.                 default:
  277.                     break;
  278.             }
  279.             redraw(wi_handle, &box);    /* redraw window */
  280.             mvslide();
  281.             break;
  282.  
  283.         default:
  284.             break;
  285.     }
  286.  
  287.     return(done);
  288. }
  289.  
  290. /* this function do the WM_FULLED message */
  291.  
  292. toggle(msg)        
  293. int msg;
  294. {
  295.  
  296.     GRECT prv, cur, full;
  297.  
  298.     /* get the previous, current, and the full size of windows */
  299.     wind_get(msg, WF_PREVXYWH, &prv.g_x, &prv.g_y, &prv.g_w, &prv.g_h);
  300.     wind_get(msg, WF_CURRXYWH, &cur.g_x, &cur.g_y, &cur.g_w, &cur.g_h);
  301.     wind_get(msg, WF_FULLXYWH, &full.g_x, &full.g_y, &full.g_w, &full.g_h);
  302.  
  303.     /* if it is full size, change it to previous unless that was full also */
  304.  
  305.     if (((cur.g_x == full.g_x) &&
  306.          (cur.g_y == full.g_y) &&
  307.          (cur.g_w == full.g_w) &&
  308.          (cur.g_h == full.g_h)) &&
  309.              ((prv.g_x != full.g_x) ||
  310.               (prv.g_y != full.g_y) ||
  311.               (prv.g_w != full.g_w) ||
  312.               (prv.g_h != full.g_h)))     {
  313.         wind_set(msg, WF_CURRXYWH, prv.g_x, prv.g_y, prv.g_w, prv.g_h);
  314.         redraw(msg, &prv);        
  315.         xwork = prv.g_x;
  316.         ywork = prv.g_y;
  317.         hwork = prv.g_h;
  318.         wwork = prv.g_w;
  319.     } else {
  320.         wind_set(msg, WF_CURRXYWH, full.g_x, full.g_y, full.g_w, full.g_h);
  321.         xwork = full.g_x;
  322.         ywork = full.g_y;
  323.         hwork = full.g_h;
  324.         wwork = full.g_w;
  325.     }
  326. }
  327.  
  328.  
  329. /* redraw the window */
  330.  
  331. redraw(wh, dbox)    
  332.  
  333. int wh;        /* window handle from msg[3] */
  334. GRECT *dbox;    /* pointer to the redraw rectangle */
  335.  
  336. {  
  337.  
  338.     GRECT wdrct;    /* the current window rectangle in rect list */ 
  339.  
  340.     hide_mouse();        /* turn off mouse */
  341.     wind_update(BEG_UPDATE);    /* lock screen */
  342.     wind_get
  343.         (wh, WF_FIRSTXYWH, &wdrct.g_x, &wdrct.g_y, &wdrct.g_w, &wdrct.g_h);
  344.     while (wdrct.g_w && wdrct.g_h)    {    /* while it is not the last one */
  345.         if (overlap(dbox, &wdrct))    { /*check to see if this one is damaged*/ 
  346.             setclip(&wdrct, msg);          /*if it is, set clip rectangle*/
  347.             writewd(wh);                /* redraw the window */
  348.             vs_clip(wh, FALSE, (int *)&wdrct);
  349.         }
  350.         wind_get
  351.           (wh, WF_NEXTXYWH, &wdrct.g_x, &wdrct.g_y, &wdrct.g_w, &wdrct.g_h);
  352.     }
  353.     wind_update(END_UPDATE);    /* unlock screen */
  354.     show_mouse();        /* turn on mouse */
  355.  
  356. }
  357.  
  358. /* draw and display the window */
  359.  
  360. writewd(wh)
  361. int wh;
  362. {
  363.     int i;
  364.     int temp[4];
  365.  
  366.     temp[0] = xwork;
  367.     temp[1] = ywork;
  368.     temp[2] = xwork + wwork - 1;
  369.     temp[3] = ywork + hwork - 1;
  370.     v_bar(wh, temp);
  371.     for (i=0; i < (hwork-4)/gl_hchar; i++)    {
  372.         v_gtext(wh, xwork+2, gl_hchar*i + ywork+5, *(list+toptx+i));
  373.     }
  374.     toptx += i;
  375.  
  376. }
  377.  
  378.  
  379. /* move the slider to match top text */
  380.  
  381. mvslide(wh)
  382. int wh;
  383. {
  384.     int cslide, nslide;
  385.     int tmp;
  386.  
  387.     wind_get(wh, WF_VSLIDE, &cslide, &nslide, &nslide, &nslide);
  388.     tmp = 1000*toptx/(nrow-(hwork-5)/gl_hchar);
  389.     if ((nslide=tmp) != cslide)    {
  390.         wind_set(wh, WF_VSLIDE, nslide, 0, 0, 0);
  391.     }
  392. }
  393.  
  394. /* set clip to specified rectangle */
  395. setclip(p, wh)    
  396. GRECT *p;
  397. int wh;
  398.  
  399. {
  400.     int ptr[4];
  401.  
  402.     grect_conv(p, ptr);
  403.     vs_clip(wh, TRUE, ptr);
  404. }
  405.  
  406.  
  407. grect_conv(r, ar)
  408. GRECT *r;
  409. int *ar;
  410. {
  411.     *ar++ = r->g_x;
  412.     *ar++ = r->g_y;
  413.     *ar++ = r->g_x + r->g_w - 1;
  414.     *ar   = r->g_y + r->g_h - 1;
  415. }
  416.  
  417. /* compute overlap of two rectangles */
  418.  
  419. overlap(r1, r2)
  420. GRECT *r1, *r2;
  421. {
  422.     int x, y, x1, y1;
  423.  
  424.     x = MAX(r2->g_x, r1->g_x);
  425.     y = MAX(r2->g_y, r1->g_y);
  426.     r2->g_w = MIN(r2->g_x + r2->g_w, r1->g_x + r1->g_w) - x;
  427.     r2->g_h = MIN(r2->g_y + r2->g_h, r1->g_y + r1->g_h) - y;
  428.     r2->g_x = x;
  429.     r2->g_y = y;
  430.     return((r2->g_w > 0) && (r2->g_h > 0));
  431. }
  432.  
  433.  
  434. fatal(error, msg)
  435. int error; char *msg;
  436. {
  437.     errno = -error;
  438.     perror(msg);
  439.     exit(1);
  440. }
  441.  
  442.  
  443. findsiz(buf)
  444. char *buf;
  445. {
  446.     int n=0;
  447.  
  448.     while (*buf)    {
  449.         while (*buf != 0x0D)    {
  450.             buf++;
  451.         }
  452.         n++;
  453.         buf += 2;
  454.     }
  455.     return (n);
  456. }
  457.  
  458. converstr(list, sbuff, dbuff)
  459. long *list;
  460. char *sbuff;
  461. char *dbuff;
  462. {
  463.  
  464.     long *tmp;
  465.     char *sptr, *dptr;
  466.     int i=0;
  467.  
  468.     tmp = list;
  469.     *tmp++ = dbuff;
  470.     sptr = sbuff;
  471.     dptr = dbuff;
  472.     if (*sptr == 0x0D)    { /* the first line is the blank line */
  473.         *dptr++ = 0x20;
  474.         *dptr++ = 0x00;
  475.         sptr += 2;
  476.         *tmp++ = dptr;
  477.     } 
  478.     while (*sptr)    {
  479.         while ((*sptr != 0x09) && ((*dptr++ = *sptr) != 0x0D))    {
  480.             i++;
  481.             sptr++;
  482.         }
  483.         switch(*sptr)    {
  484.             case 0x09:        /* it is a tab char */
  485.                 sptr++;
  486.                 i = 4 - i%4;    /* calculate how many space should be */
  487.                 switch(i)    {
  488.                     case 4:
  489.                         *dptr++ = 0x20;
  490.                         *dptr++ = 0x20;
  491.                         *dptr++ = 0x20;
  492.                         *dptr++ = 0x20;
  493.                         break;
  494.                     case 3:
  495.                         *dptr++ = 0x20;
  496.                         *dptr++ = 0x20;
  497.                         *dptr++ = 0x20;
  498.                         break;
  499.                     case 2:
  500.                         *dptr++ = 0x20;
  501.                         *dptr++ = 0x20;
  502.                         break;
  503.                     case 1:
  504.                         *dptr++ = 0x20;
  505.                         break;
  506.                     default:
  507.                         break;
  508.                 }
  509.                 break;
  510.             case 0x0D:        /* it is a carriage return char */
  511.                 sptr++;
  512.                 if (*(sptr-2) == 0x0A) {/* it is a blank line */
  513.                     *(dptr-1) = 0x20;
  514.                     *dptr++ = 0x00;
  515.                 } else {
  516.                     *(dptr-1) = 0x00;
  517.                 }
  518.                 *tmp++ = dptr;
  519.                 sptr++;
  520.                 break;
  521.             default:
  522.                 break;
  523.         }
  524.         i = 0;
  525.     }
  526. }
  527. /*
  528.  
  529. converstr(list, buff)
  530. long *list;
  531. char *buff;
  532. {
  533.  
  534.     long *tmp;
  535.     char *ptr;
  536.  
  537.     *list = buff;
  538.     tmp = list;
  539.     ptr = buff;
  540.     if (*ptr == 0x0D)    {  the first line is the blank line
  541.         *ptr++ = 0x20;
  542.         *ptr++ = 0x00;
  543.         *tmp++ = ptr;
  544.     } else     {
  545.         tmp++;
  546.     }
  547.     while (*ptr)    {
  548.         while (*ptr != 0x0D)    {
  549.             ptr++;
  550.         }
  551.         if ((*(ptr-1) == 0x00) || (*(ptr-1) == 0x0A)) { it is a blank line
  552.             *ptr++ = 0x20;
  553.             *ptr++ = 0x00;
  554.             *tmp++ = ptr;
  555.             continue;
  556.         }
  557.         *ptr = 0x00;
  558.         ptr += 2;
  559.         *tmp++ = ptr;
  560.     }
  561. }
  562.  
  563. */
  564.  
  565. /*
  566.  * Get a single event, process it, and return.
  567.  *
  568.  */
  569. domulti(){
  570.     int event;
  571.     long tmp;
  572.     GRECT box;
  573.  
  574.     box.g_x = xwork;
  575.     box.g_y = ywork;
  576.     box.g_h = hwork;
  577.     box.g_w = wwork;
  578.     
  579.     event = evnt_multi(MU_MESAG,
  580.             1,1,butdown,
  581.             0,0,0,0,0,
  582.             0,0,0,0,0,
  583.             msg,0,0,&mx,&my,&ret,&ret,&keycode,&ret);
  584.  
  585.     if (event & MU_MESAG) {
  586.         wind_update(TRUE);
  587.     switch (msg[0]) {
  588.         case  WM_REDRAW:        /* do the redraw by call redraw routine */
  589.             redraw(msg[3], (GRECT *)&msg[4]);
  590.             break;
  591.  
  592.         case  WM_TOPPED:        /* if topped, send to top */
  593.             wind_set(msg[3], WF_TOP, 0, 0, 0, 0);
  594.             break;
  595.  
  596.         case  WM_SIZED:            /* if sized, check for min size, then resize */
  597.             msg[6] = MAX(msg[6], gl_wchar*8);
  598.             msg[7] = MAX(msg[7], gl_hchar*4);
  599.             wind_set(msg[3], WF_CURRXYWH, msg[4], msg[5], msg[6], msg[7]);
  600.             wwork = msg[6];
  601.             hwork = msg[7];
  602.             box.g_w = msg[6];
  603.             box.g_h = msg[7];
  604.             redraw(msg[3], (GRECT *)&msg[4]);
  605.             break;
  606.  
  607.         case  WM_MOVED:            /* if moved, make sure the window stays on the
  608.                                    desktop */
  609.             if (msg[4] + msg[6] > xdesk + wdesk)    {
  610.                 msg[4] = xdesk + wdesk - msg[6];
  611.             } 
  612.             if (msg[5] + msg[7] > ydesk + hdesk)    {
  613.                 msg[5] = ydesk + hdesk - msg[7];
  614.             }
  615.             wind_set(msg[3], WF_CURRXYWH, msg[4], msg[5], msg[6], msg[7]);
  616.             xwork = msg[4];
  617.             ywork = msg[5];
  618.             box.g_x = msg[4];
  619.             box.g_y = msg[5];
  620.             break;
  621.  
  622.         case  WM_FULLED:        /* if fulled, do toggle routine */
  623.             toggle(msg[3]);
  624.             break;
  625.  
  626.         case  WM_CLOSED:        /* if closed, set flag */
  627.             wind_close(msg[3]);
  628.             break;
  629.  
  630.         case  WM_VSLID:            /* slide bar was dragged */
  631.             tmp = msg[4] * (nrow-(hwork-5)/gl_hchar) / 1000;    /* calc toptx */
  632.             toptx = tmp;
  633.             redraw(msg[3], &box);    /* redraw window */
  634.             mvslide(msg[3]);
  635.             break;
  636.  
  637.         case  WM_HSLID:            /* slide bar was dragged */
  638.             break;
  639.  
  640.         case  WM_ARROWED:
  641.             switch (msg[4])    {
  642.                 case 0:    /* page up */
  643.                     toptx = MAX(0, toptx-(hwork-5)/gl_hchar);
  644.                     break;
  645.  
  646.                 case 1:    /* page down */
  647.                     toptx = MIN(nrow-(hwork-5)/gl_hchar, 
  648.                                             toptx+(hwork-5)/gl_hchar);
  649.                     break;
  650.  
  651.                 case 2:    /* row up */
  652.                     toptx = MAX(0, toptx-1);
  653.                     break;
  654.  
  655.                 case 3:    /* row down */
  656.                     toptx = MIN(nrow-(hwork-5)/gl_hchar, toptx+1);
  657.                     break;
  658.  
  659.                 default:
  660.                     break;
  661.             }
  662.             redraw(msg[3], &box);    /* redraw window */
  663.             mvslide(msg[3]);
  664.             break;
  665.  
  666.         case MN_SELECTED:
  667.             BEE_MOUSE;
  668.         switch(msg[3]) {
  669.             case WINDOW:
  670.                 switch (msg[4]) {
  671.                     case OPENWD:
  672.                         doopenwd();
  673.                         break;
  674.                     case RDFILE:
  675.                         dordfile();
  676.                         break;
  677.                     default:        
  678.                         break;
  679.                 }
  680.                 break;
  681.  
  682.             case MNFILE:
  683.                 switch (msg[4]) {
  684.                     case FIQUIT:
  685.                     running = 0;
  686.                     break;
  687.  
  688.                         default:
  689.                         break;
  690.                 }
  691.                 break;
  692.             
  693.             case MNDESK:
  694.             /*
  695.             if(msg[4] == DABOUT) {
  696.                 strcpy(abtdial[ABVERSN].ob_spec, "Version 5.00");
  697.                  abtdial[ABOK].ob_state = NORMAL;
  698.                 execform(abtdial);
  699.             }
  700.             */
  701.             break;        /* "cannot happen" */
  702.         }
  703.  
  704.         menu_tnormal(menubar, msg[3], 1);    /* back to normal */
  705.         ARROW_MOUSE;
  706.         break;
  707.         
  708.         case WM_NEWTOP:
  709.             wind_set(wi_handle, WF_TOP, 0, 0, 0, 0);
  710.             break;
  711.  
  712.  
  713.         default:
  714.         break;
  715.     }
  716.     wind_update(FALSE);
  717.     }
  718. }
  719.  
  720. dordfile()
  721. {
  722. ;
  723. }
  724.  
  725.  
  726. /*
  727.  * Open virtual workstation.
  728.  *
  729.  */
  730. open_vwork()
  731. {
  732.     int i;
  733.  
  734.     for (i = 0; i < 10;)
  735.     work_in[i++] = 1;
  736.     work_in[10] = 2;
  737.     handle = phys_handle;
  738.     v_opnvwk(work_in, &handle, work_out);
  739. }
  740.  
  741.  
  742. /*
  743.  * Find and redraw all clipping rectangles
  744.  *
  745.  */
  746. do_redraw(xc, yc, wc, hc)
  747. int xc, yc, wc, hc;
  748. {
  749.     GRECT t1, t2;
  750.     int temp[4];
  751.  
  752.     hide_mouse();
  753.     t2.g_x=xc;
  754.     t2.g_y=yc;
  755.     t2.g_w=wc;
  756.     t2.g_h=hc;
  757.     vsf_interior(handle, 1);
  758.     vsf_color(handle, 0);
  759.     wind_get(wi_handle, WF_FIRSTXYWH, &t1.g_x, &t1.g_y, &t1.g_w, &t1.g_h);
  760.     while (t1.g_w && t1.g_h) {
  761.     if (rc_intersect(&t2, &t1)) {
  762.         set_clip(t1.g_x, t1.g_y, t1.g_w, t1.g_h);
  763.         temp[0] = xwork;
  764.         temp[1] = ywork;
  765.         temp[2] = xwork + wwork - 1;
  766.         temp[3] = ywork + hwork - 1;
  767.         v_bar(handle, temp);
  768.     }
  769.     wind_get(wi_handle, WF_NEXTXYWH, &t1.g_x, &t1.g_y, &t1.g_w, &t1.g_h);
  770.     }
  771.  
  772.     show_mouse();
  773. }
  774.  
  775.  
  776. /*
  777.  * Hide the mouse.
  778.  *
  779.  */
  780. hide_mouse()
  781. {
  782.     if (!hidden) {
  783.     graf_mouse(M_OFF, 0L);
  784.     hidden = TRUE;
  785.     }
  786. }
  787.  
  788.  
  789. /*
  790.  * Show the mouse.
  791.  *
  792.  */
  793. show_mouse() 
  794. {
  795.     if (hidden) {
  796.     graf_mouse(M_ON, 0L);
  797.     hidden = FALSE;
  798.     }
  799. }
  800.  
  801.  
  802. /*
  803.  * Set clipping rectangle.
  804.  *
  805.  */
  806. set_clip(x, y, w, h)
  807. int x, y, w, h;
  808. {
  809.     int clip[4];
  810.  
  811.     clip[0] = x;
  812.     clip[1] = y;
  813.     clip[2] = x + w;
  814.     clip[3] = y + h;
  815.     vs_clip(handle, 1, clip);
  816. }
  817.  
  818.  
  819. /*
  820.  * "Execute" form,
  821.  * return thingy that caused the exit.
  822.  *
  823.  */
  824. execform(tree)
  825. OBJECT tree[];
  826. {
  827.     int thingy;
  828.  
  829.     ARROW_MOUSE;
  830.     dsplymsg(tree);
  831.     thingy = form_do(tree, 0);
  832.     erasemsg();
  833.     BEE_MOUSE;
  834.     return thingy;
  835. }
  836.  
  837.  
  838. /*
  839.  *  Display a dialogue box on the screen.
  840.  *    Input:
  841.  *        tree - object tree for dialogue box to be displayed.
  842.  *    Output:
  843.  *        formw, formh, sx, sy, lx, ly - dimensions of box.
  844.  */
  845. dsplymsg(tree)
  846. OBJECT *tree;
  847. {
  848.     form_center(tree,&lx, &ly, &formw, &formh);
  849.  
  850.     /*
  851.     sx = lx + formw / 2;
  852.     sy = ly + formh / 2;
  853.     */
  854.     
  855.     form_dial(1, 0, 0, 0, 0, lx, ly, formw, formh);
  856.     objc_draw(tree, 0, MAX_DEPTH, 0, 0, wdesk, hdesk);
  857. }
  858.  
  859.  
  860. /*
  861.  *  Erase a dialogue box from the screen.
  862.  *    Input:
  863.  *        formw, formh, sx, sy, lx, ly - dimensions of box.
  864.  */
  865. erasemsg()
  866. {
  867.     form_dial(3, 0, 0, 0, 0, lx, ly, formw, formh);
  868. }
  869.  
  870.  
  871.  
  872. /*
  873.  *  Make a long (4-byte) random.
  874.  */ 
  875. long
  876. longrandom()
  877. {
  878.     long pattern;
  879.     
  880.     pattern = Random();
  881.     pattern <<= 16;
  882.     pattern ^= Random();
  883.     
  884.     return (pattern);
  885. }
  886.  
  887.